home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 039a / mawk.zip / SCAN.C < prev    next >
C/C++ Source or Header  |  1991-04-09  |  18KB  |  695 lines
  1.  
  2. /********************************************
  3. scan.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the Awk programming language as defined in
  8. Aho, Kernighan and Weinberger, The AWK Programming Language,
  9. Addison-Wesley, 1988.
  10.  
  11. See the accompaning file, LIMITATIONS, for restrictions
  12. regarding modification and redistribution of this
  13. program in source or binary form.
  14. ********************************************/
  15.  
  16.  
  17. /* $Log:    scan.c,v $
  18.  * Revision 2.2  91/04/09  12:39:27  brennan
  19.  * added static to funct decls to satisfy STARDENT compiler
  20.  * 
  21.  * Revision 2.1  91/04/08  08:23:51  brennan
  22.  * VERSION 0.97
  23.  * 
  24. */
  25.  
  26.  
  27. #include  "mawk.h"
  28. #include  "sizes.h"
  29. #include  "scan.h"
  30. #include  "memory.h"
  31. #include  "field.h"
  32. #include  "init.h"
  33. #include  "fin.h"
  34. #include  "repl.h"
  35. #include  <fcntl.h>
  36. #include  <string.h>
  37. #include  "files.h"
  38.  
  39.  
  40. /* static functions */
  41. static void PROTO(buff_create, (char *) ) ;
  42. static int PROTO(slow_next, (void) ) ;
  43. static void PROTO(eat_comment, (void) ) ;
  44. static double PROTO(collect_decimal, (int, int *) ) ;
  45. static int PROTO(collect_string, (void) ) ;
  46. static int  PROTO(collect_RE, (void) ) ;
  47. static char *PROTO(rm_escape, (char *) ) ;
  48.  
  49.  
  50. /*-----------------------------
  51.   program file management
  52.  *----------------------------*/
  53.  
  54. static  unsigned char *buffer ;
  55. static  unsigned char *buffp ;  
  56.     /* unsigned so it works with 8 bit chars */
  57. static  int  program_fd = -1  ; 
  58. static  int  eof_flag ;
  59.  
  60.  
  61. static void buff_create(s)
  62.   char *s ;
  63. {
  64.   /* If program_fd == -1, program came from command line and s
  65.      is it, else s is a filename */
  66.  
  67.   if ( program_fd == -1 )
  68.   { buffer = buffp = (unsigned char *) s ; eof_flag = 1 ; }
  69.   else /* s is a filename, open it */
  70.   {
  71.     if ( s[0] == '-' && s[1] == 0 ) program_fd = 0 ;
  72.     else
  73.     if ( (program_fd = open(s, O_RDONLY, 0)) == -1 )
  74.     { errmsg( errno, "cannot open %s", s) ; mawk_exit(1) ; }
  75.  
  76.     buffp = buffer = (unsigned char *) zmalloc( BUFFSZ+1 ) ;
  77.  
  78.     eof_flag = fillbuff(program_fd, buffer, BUFFSZ) < BUFFSZ ;
  79.   }
  80. }
  81.  
  82. void scan_cleanup()
  83. { 
  84.   if ( program_fd >= 0 ) zfree(buffer, BUFFSZ+1) ;
  85.   if ( program_fd > 0 )  (void) close(program_fd) ;
  86.   scan_code['\n'] = SC_SPACE ;
  87. }
  88.  
  89.  
  90. void  scan_init(flag, p)
  91.   int flag ; /* on if program is from the command line */
  92.   char *p ;
  93. { 
  94.   if ( ! flag ) program_fd = 0 ;
  95.   buff_create(p) ;
  96.  
  97.   eat_nl() ; /* scan to first token */
  98.   if ( next() == 0 )  
  99.   { errmsg(0, "no program") ; mawk_exit(1) ; }
  100.   un_next() ;
  101. }
  102.  
  103. /*--------------------------------
  104.   global variables shared by yyparse() and yylex()
  105.  *-------------------------------*/
  106.  
  107. int  current_token = -1 ; 
  108. unsigned  token_lineno ;
  109. unsigned  compile_error_count ;
  110. int   paren_cnt ;
  111. int   brace_cnt ;
  112. int   print_flag ;  /* changes meaning of '>' */
  113. int   getline_flag ; /* changes meaning of '<' */
  114.  
  115. extern  YYSTYPE  yylval ;
  116.  
  117. /*----------------------------------------
  118.  file reading functions
  119.  next() and un_next(c) are macros in scan.h
  120.  
  121.  *---------------------*/
  122.  
  123. static  unsigned lineno = 1 ;
  124.  
  125. /* used to help distinguish / as divide or start of RE  */
  126.  
  127. static int can_precede_re[] =
  128. { MATCH, NOT_MATCH, COMMA, RBRACE, 
  129. LPAREN, NOT, P_OR, P_AND, NL,  -1 } ;
  130.  
  131. /* read one character -- slowly */
  132. static int slow_next()
  133. { 
  134.   if ( *buffp == 0  )
  135.       if ( !eof_flag ) 
  136.       { buffp = buffer ;
  137.         eof_flag = fillbuff(program_fd, buffer,BUFFSZ) < BUFFSZ ;
  138.       }
  139.  
  140.   return *buffp++ ; /* note can un_next() , eof which is zero */
  141. }
  142.  
  143. static void eat_comment()
  144. { register int c ;
  145.  
  146.   while ( (c = next()) != '\n' && scan_code[c] ) ;
  147.   un_next() ;
  148. }
  149.  
  150. void eat_nl() /* eat all space including newlines */
  151. {
  152.   while ( 1 )
  153.     switch( scan_code[next()] )
  154.     { 
  155.       case SC_COMMENT : 
  156.          eat_comment() ;
  157.          break ;
  158.          
  159.       case  SC_NL  :   lineno++ ;
  160.       /* fall thru  */
  161.       case  SC_SPACE  :   break ;
  162.       default :  
  163.           un_next() ; return ;
  164.     }
  165. }
  166.  
  167. int yylex()
  168. { 
  169.   register int c ;
  170.  
  171.   token_lineno = lineno ;
  172.  
  173. reswitch:
  174.  
  175.     switch( scan_code[c = next()] )
  176.     {
  177.       case  0  :  /* if no terminator on the line put one */
  178.           if ( (c = current_token) == RBRACE ||
  179.                 c == NL || c == SEMI_COLON ) ct_ret(EOF) ;
  180.           else
  181.           { un_next() ;  ct_ret(NL) ; }
  182.           
  183.       case  SC_SPACE  :   goto reswitch ;
  184.  
  185.       case  SC_COMMENT :
  186.           eat_comment() ; goto reswitch ;
  187.  
  188.       case  SC_NL  : 
  189.           lineno++ ; eat_nl() ;
  190.           ct_ret(NL) ;
  191.  
  192.       case SC_ESCAPE :
  193.           while ( scan_code[ c = next() ] == SC_SPACE ) ;
  194.           if ( c == '\n')
  195.           { token_lineno = ++lineno ; goto reswitch ; }
  196.           if ( c == 0 )  ct_ret(EOF) ;
  197.           un_next() ;
  198.           yylval.ival = '\\' ;
  199.           ct_ret(UNEXPECTED) ;
  200.  
  201.  
  202.       case  SC_SEMI_COLON  : 
  203.           eat_nl() ;
  204.           ct_ret(SEMI_COLON) ;
  205.  
  206.       case  SC_LBRACE :  
  207.           eat_nl() ; brace_cnt++ ;
  208.           ct_ret(LBRACE) ;
  209.  
  210.       case  SC_PLUS  :
  211.           test2_ret('+', INC, '=', ADD_ASG, PLUS ) ;
  212.  
  213.       case  SC_MINUS :
  214.           test2_ret('-', DEC, '=', SUB_ASG, MINUS ) ;
  215.  
  216.       case  SC_COMMA :  eat_nl() ; ct_ret(COMMA) ;
  217.  
  218.       case  SC_MUL  :  test1_ret('=', MUL_ASG, MUL) ;
  219.       case  SC_DIV :   
  220.           { int *p = can_precede_re ;
  221.  
  222.             do
  223.                 if ( *p == current_token )
  224.                     ct_ret( collect_RE() ) ;
  225.             while ( *p++ != -1 ) ;
  226.  
  227.             test1_ret( '=', DIV_ASG , DIV ) ;
  228.           }
  229.  
  230.       case  SC_MOD  :  test1_ret('=', MOD_ASG, MOD) ;
  231.       case  SC_POW :   test1_ret('=' , POW_ASG, POW) ;
  232.       case  SC_LPAREN : 
  233.           paren_cnt++ ;
  234.           ct_ret(LPAREN) ;
  235.  
  236.       case  SC_RPAREN : 
  237.           if ( --paren_cnt < 0 )
  238.           { compile_error( "extra ')'" ) ;
  239.             paren_cnt = 0 ;
  240.             goto reswitch ; }
  241.  
  242.           ct_ret(RPAREN) ;
  243.  
  244.       case  SC_LBOX   : ct_ret(LBOX) ;
  245.       case  SC_RBOX   : ct_ret(RBOX) ;
  246.  
  247.       case  SC_MATCH  : ct_ret(MATCH) ;
  248.  
  249.       case  SC_EQUAL  :
  250.           test1_ret( '=', EQ, ASSIGN ) ;
  251.  
  252.       case  SC_NOT : /* !  */
  253.           test2_ret('=', NEQ, '~', NOT_MATCH, NOT ) ;
  254.  
  255.       case  SC_LT  :  /* '<' */
  256.           if ( getline_flag )
  257.           { getline_flag = 0 ; ct_ret(IO_IN) ; }
  258.           else
  259.           { ct_ret( ifnext('=', LTE , LT) ) ; }
  260.  
  261.       case  SC_GT  :  /* '>' */
  262.           if ( print_flag && paren_cnt == 0 )
  263.           { print_flag = 0 ;
  264.             /* there are 3 types of IO_OUT 
  265.                -- build the error string in temp_buff */
  266.             temp_buff.string_buff[0] = '>' ;
  267.             if ( next() == '>' ) 
  268.             { 
  269.               yylval.ival = F_APPEND ;
  270.               temp_buff.string_buff[1] = '>' ;
  271.               temp_buff.string_buff[2] =  0 ;
  272.             }
  273.             else
  274.             { un_next() ; 
  275.               yylval.ival = F_TRUNC ; 
  276.               temp_buff.string_buff[1] = 0 ;
  277.             }
  278.             return current_token = IO_OUT ;
  279.           }
  280.  
  281.           ct_ret( ifnext('=', GTE , GT) ) ;
  282.  
  283.       case  SC_OR :
  284.           if ( next() == '|' ) 
  285.           { eat_nl() ; ct_ret(brace_cnt?OR:P_OR) ; }
  286.           else 
  287.           { un_next() ; 
  288.  
  289.             if ( print_flag && paren_cnt == 0 )
  290.             { print_flag = 0 ; 
  291.               yylval.ival = PIPE_OUT;
  292.               temp_buff.string_buff[0] = '|' ;
  293.               temp_buff.string_buff[1] = 0 ;
  294.               ct_ret(IO_OUT) ;
  295.             }
  296.             else  ct_ret(PIPE) ;
  297.           }
  298.  
  299.       case  SC_AND :
  300.           if ( next() == '&' )  
  301.           { eat_nl() ; ct_ret(brace_cnt?AND:P_AND) ; }
  302.           else 
  303.           { un_next() ; yylval.ival = '&' ; ct_ret(UNEXPECTED) ; }
  304.  
  305.       case  SC_QMARK  :  ct_ret(QMARK) ;
  306.       case  SC_COLON  :  ct_ret(COLON) ;
  307.       case  SC_RBRACE :
  308.           if ( --brace_cnt < 0 )
  309.           { compile_error("extra '}'" ) ;
  310.             brace_cnt = 0 ; goto reswitch ; }
  311.  
  312.           if ( (c = current_token) == NL || c == SEMI_COLON 
  313.                || c == SC_FAKE_SEMI_COLON  || c == RBRACE  )
  314.           { eat_nl() ; ct_ret(RBRACE) ; }
  315.  
  316.           brace_cnt++ ; un_next() ;
  317.           current_token = SC_FAKE_SEMI_COLON ;
  318.           return  SEMI_COLON ;
  319.  
  320.       case  SC_DIGIT  :
  321.       case  SC_DOT    :
  322.           { double d ;
  323.             int flag ;
  324.  
  325.             if ( (d = collect_decimal(c, &flag)) == 0.0 )
  326.                 if ( flag )  ct_ret(flag) ;
  327.                 else  yylval.cp = &cell_zero ;
  328.             else if ( d == 1.0 ) yylval.cp = &cell_one ;
  329.             else 
  330.             { yylval.cp = new_CELL() ;
  331.               yylval.cp->type = C_DOUBLE ;
  332.               yylval.cp->dval = d ; 
  333.             }
  334.             ct_ret( CONSTANT ) ;
  335.           }
  336.  
  337.       case  SC_DOLLAR :  /* '$' */
  338.           { double d ;
  339.             int flag ;
  340.  
  341.             while ( scan_code[c = next()] == SC_SPACE )  ;
  342.             if ( scan_code[c] != SC_DIGIT &&
  343.                  scan_code[c] != SC_DOT )
  344.             { un_next() ; ct_ret(DOLLAR) ; }
  345.             /* compute field address at compile time */
  346.             if ( (d = collect_decimal(c, &flag)) == 0.0 )
  347.                 if ( flag )  ct_ret(flag) ; /* an error */
  348.                 else  yylval.cp = &field[0] ;
  349.             else
  350.             { int k = (int) d ;
  351.  
  352.               if ( k > MAX_FIELD )
  353.               { compile_error(
  354.                    "maximum field index(%d) exceeded" , k ) ;
  355.                 k = MAX_FIELD ;
  356.               }
  357.               else  yylval.cp = &field[k] ;
  358.             }
  359.  
  360.             ct_ret(FIELD) ;
  361.           }
  362.  
  363.       case  SC_DQUOTE :
  364.           return current_token = collect_string() ;
  365.  
  366.       case  SC_IDCHAR : /* collect an identifier */
  367.             { unsigned char *p =
  368.                     (unsigned char *)temp_buff.string_buff + 1 ;
  369.               SYMTAB *stp ;
  370.  
  371.               temp_buff.string_buff[0] = c ;
  372.  
  373.               while ( 
  374.                 (c = scan_code[ *p++ = next()]) == SC_IDCHAR ||
  375.                        c == SC_DIGIT )  ;
  376.               
  377.               un_next() ; * --p = 0 ;
  378.  
  379.               switch( (stp = find(temp_buff.string_buff))->type )
  380.               { case ST_NONE :  
  381.                   /* check for function call before defined */
  382.                       if ( next() == '(' )
  383.                       { stp->type = ST_FUNCT ;
  384.                         stp->stval.fbp = (FBLOCK *)
  385.                                 zmalloc(sizeof(FBLOCK)) ;
  386.                         stp->stval.fbp->name = stp->name ;
  387.                         stp->stval.fbp->code = (INST *) 0 ;
  388.                         yylval.fbp = stp->stval.fbp ;
  389.                         current_token = FUNCT_ID ;
  390.                       }
  391.                       else
  392.                       { yylval.stp = stp ;
  393.                         current_token = ID ;
  394.                       }
  395.                       un_next() ;
  396.                       break ;
  397.                         
  398.                 case ST_VAR :
  399.                 case  ST_ARRAY :
  400.                 case  ST_LOCAL_NONE :
  401.                 case  ST_LOCAL_VAR :
  402.                 case  ST_LOCAL_ARRAY :
  403.  
  404.                       yylval.stp = stp ;
  405.                       current_token = ID ;
  406.                       break ;
  407.  
  408.                 case ST_FUNCT :
  409.                       yylval.fbp = stp->stval.fbp ;
  410.                       current_token = FUNCT_ID ;
  411.                       break ;
  412.  
  413.                 case ST_KEYWORD :  
  414.                       current_token = stp->stval.kw ;
  415.                       break ;
  416.  
  417.                 case  ST_BUILTIN :
  418.                       yylval.bip = stp->stval.bip ;
  419.                       current_token = BUILTIN ;
  420.                       break ;
  421.  
  422.                 case  ST_FIELD  :
  423.                       yylval.cp = stp->stval.cp ;
  424.                       current_token = FIELD ;
  425.                       break ;
  426.  
  427.                 case  ST_LENGTH  :
  428.                     { CELL *bi_length() ;
  429.                       static BI_REC length_bi_rec =
  430.                       { "length", bi_length, 1, 1 } ;
  431.  
  432.                       while ( scan_code[ c = next() ] == SC_SPACE ) ;
  433.                       un_next() ;
  434.  
  435.                       if ( c == '(' )
  436.                       { yylval.bip = &length_bi_rec ;
  437.                         current_token = BUILTIN ;
  438.                       }
  439.                       else current_token = LENGTH ;
  440.                     }
  441.                     break ;
  442.  
  443.                 default : 
  444.                       bozo("find returned bad st type") ;
  445.               }
  446.               return  current_token  ;
  447.             }
  448.  
  449.  
  450.       case  SC_UNEXPECTED :
  451.             yylval.ival = c & 0xff ;
  452.             ct_ret(UNEXPECTED) ;
  453.     }
  454.     return  0 ; /* never get here make lint happy */
  455. }
  456.  
  457. /* collect a decimal constant in temp_buff.
  458.    Return the value and error conditions by reference */
  459.  
  460. static double collect_decimal(c, flag)
  461.   int c ; int *flag ;
  462. { register unsigned char *p = (unsigned char*) temp_buff.string_buff + 1;
  463.   unsigned char *endp ;
  464.   double d ;
  465.  
  466.   *flag = 0 ;
  467.   temp_buff.string_buff[0] = c ;
  468.  
  469.   if ( c == '.' )
  470.   { if ( scan_code[*p++ = next()] != SC_DIGIT )
  471.     { *flag = UNEXPECTED ; yylval.ival = '.' ;
  472.       return 0.0 ; }
  473.   }
  474.   else
  475.   {  while ( scan_code[*p++ = next()] == SC_DIGIT ) ;
  476.      if ( p[-1] != '.' )
  477.      { un_next() ; p-- ; }
  478.   }
  479.   /* get rest of digits after decimal point */
  480.   while ( scan_code[*p++ = next()] == SC_DIGIT )  ;
  481.  
  482.   /* check for exponent */
  483.   if ( p[-1] != 'e' && p[-1] != 'E' )
  484.   { un_next() ; * --p = 0 ; }
  485.   else  /* get the exponent */
  486.     if ( scan_code[*p = next()] != SC_DIGIT &&
  487.          *p != '-' && *p != '+' )
  488.     { *++p = 0 ; *flag = BAD_DECIMAL ;
  489.       return 0.0 ; }
  490.     else  /* get the rest of the exponent */
  491.     { p++ ;
  492.       while ( scan_code[*p++ = next()] == SC_DIGIT )  ;
  493.       un_next() ; * --p = 0 ;
  494.     }
  495.  
  496.   errno = 0 ; /* check for overflow/underflow */
  497.   d = strtod( temp_buff.string_buff, &endp ) ;
  498.   if ( errno )
  499.       compile_error( "%s : decimal %sflow" , temp_buff.string_buff,
  500.         d == 0.0 ? "under" : "over") ;
  501.   if ( endp != p )
  502.   { *flag = BAD_DECIMAL ; return 0.0 ; }
  503.   return d ;
  504. }
  505.  
  506. /*----------  process escape characters ---------------*/
  507.  
  508. static char hex_val['f' - 'A' + 1] = {
  509. 10,11,12,13,14,15, 0, 0,
  510.  0, 0, 0, 0, 0, 0, 0, 0,
  511.  0, 0, 0, 0, 0, 0, 0, 0,
  512.  0, 0, 0, 0, 0, 0, 0, 0,
  513. 10,11,12,13,14,15 } ;
  514.  
  515. #define isoctal(x)  ((x)>='0'&&(x)<='7')
  516.  
  517. #define  hex_value(x)   hex_val[(x)-'A']
  518.  
  519. #define ishex(x) (scan_code[x] == SC_DIGIT ||\
  520.                   'A' <= (x) && (x) <= 'f' && hex_value(x))
  521.  
  522. static int PROTO(octal, (char **)) ;
  523. static int PROTO(hex, (char **)) ;
  524.  
  525. /* process one , two or three octal digits
  526.    moving a pointer forward by reference */
  527. static int octal( start_p )
  528.   char **start_p ;
  529. { register char *p = *start_p ;
  530.   register unsigned x ;
  531.  
  532.   x = *p++ - '0' ;
  533.   if ( isoctal(*p) )
  534.   {
  535.     x = (x<<3) + *p++ - '0' ;
  536.     if ( isoctal(*p) )   x = (x<<3) + *p++ - '0' ;
  537.   }
  538.   *start_p = p ;
  539.   return  x & 0xff ;
  540. }
  541.  
  542. /* process one or two hex digits
  543.    moving a pointer forward by reference */
  544.  
  545. static int  hex( start_p )
  546.   unsigned char **start_p ;
  547. { register unsigned char *p = *start_p ;
  548.   register unsigned x ;
  549.   unsigned t ;
  550.  
  551.   if ( scan_code[*p] == SC_DIGIT )
  552.         x = *p++ - '0' ;
  553.   else  x = hex_value(*p++) ;
  554.  
  555.   if ( scan_code[*p] == SC_DIGIT )
  556.         x = (x<<4) + *p++ - '0' ;
  557.   else
  558.   if ( 'A' <= *p && *p <= 'f' && (t = hex_value(*p)) )
  559.   { x = (x<<4) + t ; p++ ; }
  560.  
  561.   *start_p = p ;
  562.   return x ;
  563. }
  564.  
  565. static char escape_test[] = 
  566.   "n\nt\tb\br\rf\fa\07v\013\\\\\"\"\'\'" ;
  567.  
  568. /* process the escape characters in a string, in place . */
  569.  
  570. static char *rm_escape(s)
  571.   char *s ;
  572. { register char *p, *q ;
  573.   char *t ;
  574.  
  575.   q = p = s ;
  576.  
  577.   while ( *p )
  578.       if ( *p == '\\' )
  579.       { 
  580.         if ( t = strchr(escape_test, * ++p) )
  581.         { 
  582.           p++ ; *q++ = t[1] ; 
  583.         }
  584.         else
  585.         if ( isoctal(*p) ) 
  586.         {
  587.           t = p ;  *q++ = octal(&t) ; p = t ;
  588.         }
  589.         else
  590.         if ( *p == 'x' && ishex(*(unsigned char*)(p+1)) )
  591.         {
  592.           t = p+1 ; *q++ = hex(&t) ; p = t ;
  593.         }
  594.         else  /* not an escape sequence */
  595.         { 
  596.           *q++ = '\\' ; *q++ = *p++ ;
  597.         }
  598.       }
  599.       else  *q++ = *p++ ;
  600.  
  601.   *q = 0 ;
  602.   return s ;
  603. }
  604.  
  605. static  int  collect_string()
  606. { register unsigned char *p = (unsigned char *)temp_buff.string_buff ;
  607.   int c ;
  608.   int e_flag = 0 ; /* on if have an escape char */
  609.  
  610.   while ( 1 )
  611.       switch( scan_code[ *p++ = next() ] )
  612.       { case  SC_DQUOTE : /* done */
  613.               * --p = 0 ;  goto out ;
  614.  
  615.         case  SC_NL :
  616.               p[-1] = 0 ;
  617.               /* fall thru */
  618.  
  619.         case  0 :   /* unterminated string */
  620.               compile_error(
  621.               "runaway string constant \"%.10s ..." ,
  622.               temp_buff.string_buff, token_lineno ) ;
  623.               mawk_exit(1) ;
  624.  
  625.         case SC_ESCAPE :
  626.               if ( (c = next()) == '\n' )
  627.               { p-- ; lineno++ ; }
  628.               else  
  629.                 if ( c == 0 )  un_next() ;   
  630.                 else 
  631.                 { *p++ = c ; e_flag = 1 ; }
  632.  
  633.               break ;
  634.  
  635.         default : break ;
  636.       }
  637.  
  638. out:
  639.     yylval.cp = new_CELL() ;
  640.     yylval.cp->type = C_STRING ;
  641.     yylval.cp->ptr = (PTR) new_STRING(
  642.          e_flag ? rm_escape( temp_buff.string_buff ) 
  643.                 : temp_buff.string_buff ) ;
  644.     return  CONSTANT ;
  645. }
  646.  
  647.  
  648. static  int  collect_RE()
  649. { register unsigned char *p = (unsigned char*) temp_buff.string_buff ;
  650.   int c ;
  651.   STRING *sval ;
  652.  
  653.   while ( 1 )
  654.       switch( scan_code[ *p++ = next() ] )
  655.       { case  SC_DIV : /* done */
  656.               * --p = 0 ;  goto out ;
  657.  
  658.         case  SC_NL :
  659.               p[-1] = 0 ;
  660.               /* fall thru */
  661.  
  662.         case  0 :   /* unterminated re */
  663.               compile_error(
  664.               "runaway regular expression /%.10s ..." ,
  665.               temp_buff.string_buff, token_lineno ) ;
  666.               mawk_exit(1) ;
  667.  
  668.         case SC_ESCAPE :
  669.               switch( c = next() )
  670.               { case '/' :  
  671.                       p[-1] = '/' ; break ;
  672.  
  673.                 case '\n' :
  674.                       p-- ;  break ;
  675.  
  676.                 case  0   :
  677.                       un_next() ;  break ;
  678.  
  679.                 default :
  680.                       *p++ = c ; break ;
  681.               }
  682.               break ;
  683.       }
  684.  
  685. out:
  686.   /* now we've got the RE, so compile it */
  687.   sval = new_STRING( temp_buff.string_buff ) ;
  688.   yylval.cp = new_CELL() ;
  689.   yylval.cp->type = C_RE ;
  690.   yylval.cp->ptr = re_compile(sval) ;
  691.   free_STRING(sval) ;
  692.   return RE ;
  693. }
  694.  
  695.